
#include <gtest/gtest.h>
#include <iostream>

#include <stdexcept>

void throw_exception() {
    throw std::runtime_error("An error occurred");
}

// TEST(ExceptionTest, ThrowException) {
//     EXPECT_THROW(throw_exception(), std::runtime_error);  // 通过
//     EXPECT_THROW(throw_exception(), std::invalid_argument);  // 失败，测试继续

//     ASSERT_THROW(throw_exception(), std::runtime_error);  // 通过
//     ASSERT_THROW(throw_exception(), std::invalid_argument);  // 失败，测试停止
// }

TEST(ExceptionTest, NoThrow) {
    EXPECT_NO_THROW(throw_exception());  // 失败，测试继续
    EXPECT_NO_THROW(int x = 5);  // 通过

    ASSERT_NO_THROW(throw_exception());  // 失败，测试停止
    ASSERT_NO_THROW(int x = 5);  // 通过
}


int main(int argc,char *argv[])
{
    testing::InitGoogleTest(&argc,argv);
    //运行所有测试用例
    return RUN_ALL_TESTS();
}


// int add(int a, int b) {
//     return a + b;
// }

// TEST(ConditionTest, IsTrue) {
//     EXPECT_TRUE(2 + 3 == 5);  // 通过
//     EXPECT_TRUE(2 + 3 == 6);  // 失败，测试继续

//     ASSERT_TRUE(2 + 3 == 5);  // 通过
//     ASSERT_TRUE(2 + 3 == 6);  // 失败，测试停止
// }


// TEST(ComparisonTest, GreaterThanOrEqual) {
//     EXPECT_GE(3, 2);  // 通过
//     EXPECT_GE(3, 3);  // 通过
//     EXPECT_GE(2, 3);  // 失败，测试继续
//     ASSERT_GE(3, 2);  // 通过
//     ASSERT_GE(3, 3);  // 通过
//     ASSERT_GE(2, 3);  // 失败，测试停止
// }


// TEST(ComparisonTest, GreaterThan) {
//     EXPECT_GT(3, 2);  // 通过
//     EXPECT_GT(2, 3);  // 失败，测试继续
//     ASSERT_GT(3, 2);  // 通过
//     ASSERT_GT(2, 3);  // 失败，测试停止
// }


// TEST(ComparisonTest, LessThanOrEqual) {
//     EXPECT_LE(2, 3);  // 通过
//     EXPECT_LE(3, 3);  // 通过
//     EXPECT_LE(5, 3);  // 失败，测试继续
//     ASSERT_LE(2, 3);  // 通过
//     ASSERT_LE(3, 3);  // 通过
//     ASSERT_LE(5, 3);  // 失败，测试停止
// }


// TEST(ComparisonTest, LessThan) {
//     EXPECT_LT(2, 3);  // 通过
//     EXPECT_LT(5, 3);  // 失败，测试继续
//     ASSERT_LT(2, 3);  // 通过
//     ASSERT_LT(5, 3);  // 失败，测试停止
// }




// TEST(AddTest, NotEqual) {
//     EXPECT_NE(add(2, 3), 6);  // 通过
//     EXPECT_NE(add(2, 2), 5);  // 通过
//     ASSERT_NE(add(1, 1), 3);  // 失败，测试停止
//     ASSERT_NE(add(2, 3), 6);  // 通过
    
// }

// TEST(AddTest, PositiveNumbers) {
//     EXPECT_EQ(add(2, 3), 5);  // 这条断言通过
//     EXPECT_EQ(add(1, 1), 3);  // 这条断言失败，但测试继续执行
// }

// TEST(AddTest, AssertEqual) {
//     ASSERT_EQ(add(2, 3), 5);  // 通过
//     std::cout<<"测试输出:assert_eq前"<<std::endl;
//     ASSERT_EQ(add(1, 1), 3);  // 失败，当前测试停止
//     std::cout<<"测试输出:assert_eq后"<<std::endl;

// }








// #include <gtest/gtest.h>

// // 一个简单的测试案例
// TEST(SampleTest, BasicAssertions) {
//     EXPECT_EQ(1, 1);  // 测试是否 1 等于 1
// }

// int main(int argc, char **argv) {
//     ::testing::InitGoogleTest(&argc, argv);
//     return RUN_ALL_TESTS();
// }


// #include<iostream>
// #include<gtest/gtest.h>

// int add(int x , int y)
// {
//     return x+y;
// }

// TEST(函数测试,加法函数测试1)
// {
//     //判断最终结果是否为40
//     ASSERT_EQ(add(20,20),40);
//     ASSERT_LT(add(10,10),30);
// }

// TEST(函数测试, 字符串测试)
// {
//     std::string str = "hello gtest";
//     ASSERT_EQ(str, std::string("hello gtest"));  // 类型一致
//     ASSERT_EQ(str, std::string("hello world")); // 比较失败
// }


// int main(int argc,char *argv[])
// {
//     testing::InitGoogleTest(&argc,argv);
//     //运行所有测试用例
//     return RUN_ALL_TESTS();
// }

